Как я могу удалить определенный элемент из массива?

1
2
3
4
следующий
Найдите индекс элемента массива, который вы хотите удалить, с помощью indexOf, а затем удалите этот индекс с помощью splice.
Метод splice () изменяет содержимое массива, удаляя
существующие элементы и / или добавление новых элементов.
константный массив = [2, 5, 9];
console.log (массив);
const index = array.indexOf (5);
if (index> -1) {
array.splice (индекс, 1);
}
// массив = [2, 9]
console.log (массив);
Второй параметр сращивания - это количество удаляемых элементов. Обратите внимание, что splice изменяет массив на месте и возвращает новый массив, содержащий элементы, которые были удалены.
Для полноты здесь представлены функции. Первая функция удаляет только одно вхождение (т.е. удаляет первое совпадение 5 из [2,5,9,1,5,8,5]), а вторая функция удаляет все вхождения:
function removeItemOnce (arr, value) {
var index = arr.indexOf (значение);
if (index> -1) {
arr.splice (индекс, 1);
}
возврат обр;
}
function removeItemAll (arr, value) {
var i = 0;
while (i  = 0; i--) {
if (array [i] === число) {
array.splice (я, 1);
}
}
Если вы просто хотите, чтобы элемент с индексом i больше не существовал, но вы не хотите, чтобы индексы других элементов менялись:
удалить массив [i];
|
Отредактировано: октябрь 2016 г.
Сделайте это просто, интуитивно понятно и ясно (бритва Оккама)
Сделайте это неизменным (исходный массив останется без изменений)
Делайте это со стандартными функциями JavaScript, если ваш браузер их не поддерживает - используйте polyfill
В этом примере кода я использую функцию array.filter (...) для удаления нежелательных элементов из массива. Эта функция не изменяет исходный массив, а создает новый. Если ваш браузер не поддерживает эту функцию (например, Internet Explorer до версии 9 или Firefox до версии 1.5), рассмотрите возможность использования полифила фильтра от Mozilla.
Удаление элемента (код ECMA-262 Edition 5, также известный как JavaScript старого стиля)
значение переменной = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (функция (элемент) {
вернуть товар! == значение
})
console.log (прибл)
// [1, 2, 4, 5]
Удаление элемента (код ECMAScript 6)
пусть значение = 3
пусть arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == значение)
console.log (прибл)
// [1, 2, 4, 5]
ВАЖНО ECMAScript 6 "() => {}" синтаксис стрелочной функции вообще не поддерживается в Internet Explorer, Chrome до 45 версии, Firefox до 22 версии и Safari до 10 версии. Чтобы использовать синтаксис ECMAScript 6 в старых браузерах, вы можете использовать BabelJS.
Удаление нескольких элементов (код ECMAScript 7)
Дополнительным преимуществом этого метода является то, что вы можете удалить несколько элементов.
пусть forDeletion = [2, 3, 5]
пусть arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (элемент =>! forDeletion.includes (элемент))
// !!! Читайте ниже о поддержке array.includes (...) !!!
console.log (прибл)
// [1, 4]
ВАЖНО Функция array.includes (...) вообще не поддерживается в Internet Explorer, Chrome до 47 версии, Firefox до 43 версии, Safari до 9 версии и Edge до 14 версии, так что вот полифил от Mozilla.
Удаление нескольких элементов (возможно, в будущем)
Если предложение "This-Binding Syntax" когда-либо будет принято, вы сможете сделать это:
// массив-lib.js
функция экспорта remove (... forDeletion) {
вернуть this.filter (item =>! forDeletion.includes (item))
}
// main.js
импортировать {удалить} из './array-lib.js'
пусть arr = [1, 2, 3, 4, 5, 3]
// :: Предложение синтаксиса this-Binding
// используя функцию "удалить" как "виртуальный метод"
// без расширения Array.prototype
arr = arr :: remove (2, 3, 5)
console.log (прибл)
// [1, 4]
Попробуйте сами в BabelJS :)
Справка
Array.prototype.includes
Функциональный состав
|
Это зависит от того, хотите вы оставить пустое место или нет.
Если вам нужен пустой слот:
массив [индекс] = undefined;
Если вам не нужен пустой слот:
// Чтобы сохранить оригинал:
// oldArray = [... массив];
// Это изменяет массив.
array.splice (индекс, 1);
И если вам нужно значение этого элемента, вы можете просто сохранить возвращаемый элемент массива:
значение переменной = array.splice (индекс, 1) [0];
Если вы хотите удалить с любого конца массива, вы можете использовать array.pop () для последнего или array.shift () для первого (оба возвращают значение элемента).
Если вы не знаете индекс элемента, вы можете использовать array.indexOf (item), чтобы получить его (в if (), чтобы получить один элемент, или через while (), чтобы получить их все). array.indexOf (item) возвращает либо индекс, либо -1, если не найден.
|
У друга возникли проблемы с Internet Explorer 8, и он показал мне, что он делал. Я сказал ему, что это неправильно, и он сказал мне, что получил ответВот. Текущий верхний ответ не будет работать во всех браузерах (например, Internet Explorer 8) и удалит только первое вхождение элемента.
Удалить ВСЕ экземпляры из массива
функция array_remove_index_by_value (arr, item)
{
для (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Он просматривает массив в обратном направлении (поскольку индексы и длина изменяются по мере удаления элементов) и удаляет элемент, если он найден. Работает во всех браузерах.
|
Есть два основных подхода:
splice (): anArray.splice (индекс, 1);
удалить: удалить массив [индекс];
Будьте осторожны при использовании удаления для массива. Это хорошо для удаления атрибутов объектов, но не очень хорошо для массивов. Для массивов лучше использовать splice.
Имейте в виду, что при использовании delete для массива вы можете получить неверные результаты для anArray.length. Другими словами, delete удалит элемент, но не обновит значение свойства length.
Вы также можете ожидать появления дыр в индексных номерах после использования delete, например вы можете получить индексы 1, 3, 4, 8, 9 и 11 и длину, как это было до использования удаления. В этом случае произойдет сбой всех проиндексированных циклов for, поскольку индексы больше не являются последовательными.
Если вы по какой-то причине вынуждены использовать delete, тогда вы должны использовать для каждого цикла, когда вам нужно перебирать массивы. На самом деле, по возможности всегда избегайте использования индексированных циклов for. Таким образом код будет более надежным и менее подверженным проблемам с индексами.
|
Array.prototype.remove_by_value = function (val) {
for (var i = 0; i  row.id === 5);
var удалены = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Определение
var helper = {
// Удаляем и возвращаем первое вхождение
removeOne: function (массив, предикат) {
for (var i = 0; i  [2, 3, 4]
|
Вы можете использовать ES6. Например, чтобы удалить значение «3» в этом случае:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((значение) => значение! = '3');
console.log (newArray);
Выход :
[«1», «2», «4», «5», «6»]
|
Если вы хотите создать новый массив с удаленными позициями, вы всегда можете удалить определенный элемент и отфильтровать массив. Возможно, потребуется расширение объекта массива для браузеров, которые не реализуют метод фильтрации, но в долгосрочной перспективе это проще, поскольку все, что вам нужно сделать, это:
var my_array = [1, 2, 3, 4, 5, 6];
удалить my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Он должен отобразить [1, 2, 3, 4, 6].
|
Вот несколько способов удалить элемент из массива с помощью JavaScript.
Все описанные методы не изменяют исходный массив, а вместо этого создают новый.
Если вы знаете индекс предмета
Предположим, у вас есть массив, и вы хотите удалить элемент в позиции i.
Один из способов - использовать slice ():
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const i = 3
const filterItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filterItems)
slice () создает новый массив с полученными индексами. Мы просто создаем новый массив от начала до индекса, который хотим удалить, и объединяем другой массив из первой позиции, следующей за той, которую мы удалили, до конца массива.
Если ты знаешь цену
В этом случае хороший вариант - использовать filter (), который предлагает более декларативный подход:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
константа valueToRemove = 'c'
const filterItems = items.filter (item => item! == valueToRemove)
console.log (filterItems)
Здесь используются стрелочные функции ES6. Вы можете использовать традиционные функции для поддержки старых браузеров:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
константа valueToRemove = 'c'
const filterItems = items.filter (function (item) {
вернуть элемент! == valueToRemove
})
console.log (filterItems)
или вы можете использовать Babel и перенести код ES6 обратно в ES5, чтобы сделать его более удобоваримым для старых браузеров, но при этом написать в коде современный JavaScript.
Удаление нескольких элементов
Что, если вместо одного элемента вы хотите удалить несколько элементов?
Найдем самое простое решение.
По индексу
Вы можете просто создать функцию и последовательно удалять элементы:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (элементы, я) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filterItems = removeItem (элементы, 3)
filterItems = removeItem (filterItems, 5)
// ["a", "b", "c", "d"]
console.log (filterItems)
По стоимости
Вы можете искать включение внутри функции обратного вызова:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filterItems = items.filter (item =>! valuesToRemove.includes (элемент))
// [«а», «б», «д», «е»]
console.log (filterItems)
Избегайте изменения исходного массива
splice () (не путать с slice ()) изменяет исходный массив, и этого следует избегать.
(изначально размещено на моем сайте https://flaviocopes.com/how-to-remove-item-from-array/)
|
Посмотрите этот код. Он работает во всех основных браузерах.
remove_item = function (arr, value) {
var b = '';
for (b in arr) {
if (arr [b] === значение) {
arr.splice (b, 1);
перемена;
}
}
возврат обр;
};
Вызовите эту функцию
remove_item (массив, значение);
|
ES6 и без мутации: (октябрь 2016 г.)
const removeByIndex = (список, индекс) =>
[
... list.slice (0, индекс),
... list.slice (индекс + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (вывод)
|
Вы можете использовать lodash _.pull (изменять массив), _.pullAt (изменять массив) или _.without (не изменять массив),
var array1 = ['a', 'b', 'c', 'd']
_.pull (массив1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (массив2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['я', 'j', 'k', 'l']
|
Удаление определенного элемента / строки из массива может быть выполнено в однострочном режиме:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
где:
theArray: массив, из которого вы хотите удалить что-то конкретное
stringToRemoveFromArray: строка, которую вы хотите удалить, а 1 - количество элементов, которые вы хотите удалить.
НОТА: Если «stringToRemoveFromArray» не находится в вашем массиве, это удалит последний элемент массива.
Всегда полезно сначала проверить, существует ли элемент в вашем массиве, прежде чем удалять его.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Если у вас есть доступ к более новым версиям Ecmascript на компьютерах вашего клиента (ВНИМАНИЕ, может не работать на старых станциях):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((значение) => значение! = '3');
Где «3» - это значение, которое вы хотите удалить из массива.
Тогда массив будет выглядеть так: ['1', '2', '4', '5', '6']
|
Хорошо, например, у вас есть массив ниже:
var num = [1, 2, 3, 4, 5];
И мы хотим удалить номер 4. Вы можете просто использовать приведенный ниже код:
num.splice (num.indexOf (4), 1); // число будет [1, 2, 3, 5];
Если вы повторно используете эту функцию, вы пишете функцию многократного использования, которая будет присоединена к функции собственного массива, как показано ниже:
Array.prototype.remove = Array.prototype.remove || function (x) {
const i = this.indexOf (x);
если (я === - 1)
возвращение;
this.splice (я, 1); // num.remove (5) === [1, 2, 3];
}
Но как насчет того, чтобы у вас был приведенный ниже массив с несколькими [5] в массиве?
var num = [5, 6, 5, 4, 5, 1, 5];
Нам нужен цикл для их проверки, но более простой и эффективный способ - использовать встроенные функции JavaScript, поэтому мы пишем функцию, которая вместо этого использует фильтр, как показано ниже:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Возвращаем [1, 2, 3, 4, 6]
Также существуют сторонние библиотеки, которые действительно помогут вам в этом, например Lodash или Underscore. Для получения дополнительной информации посмотрите lodash _.pull, _.pullAt или _.without.
|
Производительность
Сегодня (2019-12-09) я провожу тесты производительности на macOS v10.13.6 (High Sierra) для выбранных решений. Я показываю delete (A), но не использую его по сравнению с другими методами, потому что он оставил пустое место в массиве.
Выводы
самое быстрое решение - array.splice (C) (кроме Safari для небольших массивов, где он используется во второй раз)
для больших массивов array.slice + splice (H) - самое быстрое неизменяемое решение для Firefox и Safari; Array.from (B) самый быстрый в Chrome
изменяемые решения обычно в 1,5-6 раз быстрее, чем неизменяемые
для небольших таблиц в Safari, на удивление, изменяемое решение (C) медленнее, чем неизменное решение (G)
Детали
В тестах я удаляю средний элемент из массива разными способами. Решения A, C на месте. Решения B, D, E, F, G, H неизменны.
Результаты для массива из 10 элементов
В Chrome array.splice (C) - самое быстрое решение на месте. Array.filter (D) - самое быстрое неизменное решение. Самый медленный - array.slice (F). Здесь вы можете выполнить тест на своей машине.
Результаты для массива с 1.000.000 элементов
В Chrome array.splice (C) является самым быстрым решением на месте (удаление (C) аналогично быстрому, но оно оставило пустой слот в массиве (поэтому оно не выполняет «полное удаление»)). Array.slice-splice (H) - самое быстрое неизменное решение. Самый медленный - array.filter (D и E). Здесь вы можете выполнить тест на своей машине.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
функция A (массив) {
var index = array.indexOf (5);
удалить массив [индекс];
журнал ('A', массив);
}
функция B (массив) {
var index = array.indexOf (5);
var arr = Array.from (массив);
arr.splice (индекс, 1)
журнал ('B', обр);
}
функция C (массив) {
var index = array.indexOf (5);
array.splice (индекс, 1);
журнал ('C', массив);
}
функция D (массив) {
var arr = array.filter (элемент => элемент! == 5)
журнал ('D', обр);
}
функция E (массив) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
журнал ('E', arr);
}
функция F (массив) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
журнал ('F', обр);
}
функция G (массив) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
журнал ('G', обр);
}
функция H (массив) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (индекс, 1);
журнал ('H', arr);
}
А ([... а]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
В этом фрагменте кода представлен только код, используемый в тестах производительности - он не выполняет тесты.
Сравнение для браузеров: Chrome v78.0.0, Safari v13.0.4 и Firefox v71.0.0
|
Я новичок в JavaScript и нуждался в этой функциональности. Я просто написал это:
function removeFromArray (массив, элемент, индекс) {
while ((index = array.indexOf (item))> -1) {
array.splice (индекс, 1);
}
}
Затем, когда я захочу его использовать:
// Устанавливаем фиктивные данные
var dummyObj = {имя: "мяу"};
var dummyArray = [dummyObj, «элемент1», «элемент1», «элемент2»];
// Удаляем фиктивные данные
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, «элемент2»);
Результат - как и ожидалось.
["элемент1", "элемент1"]
У вас могут быть другие потребности, чем у меня, поэтому вы можете легко изменить егочтобы удовлетворить их. Я надеюсь, что это помогает кому-то.
|
Если у вас есть сложные объекты в массиве, вы можете использовать фильтры?
В ситуациях, когда использовать $ .inArray или array.splice не так просто. Особенно, если объекты в массиве могут быть неглубокими.
Например. если у вас есть объект с полем Id, и вы хотите, чтобы объект был удален из массива:
this.array = this.array.filter (function (element, i) {
return element.id! == idToRemove;
});
|
Я хочу ответить на основе ECMAScript 6. Предположим, у вас есть массив, как показано ниже:
пусть arr = [1,2,3,4];
Если вы хотите удалить по специальному индексу, например 2, напишите следующий код:
arr.splice (2, 1); // => arr стало [1,2,4]
Но если вы хотите удалить специальный элемент, например 3, и не знаете его индекс, сделайте следующее:
arr = arr.filter (e => e! == 3); // => arr стало [1,2,4]
Подсказка: используйте стрелочную функцию для обратного вызова фильтра, если вы не получите пустой массив.
|
Обновление: этот метод рекомендуется только в том случае, если вы не можете использовать ECMAScript 2015 (ранее известный как ES6). Если вы можете его использовать, другие ответы здесь предоставляют гораздо более аккуратные реализации.
Эта суть решит вашу проблему, а также удалит все вхождения аргумента вместо 1 (или указанного значения).
Array.prototype.destroy = function (obj) {
// Возвращаем null, если объекты не были найдены и удалены
вар уничтожен = ноль;
for (var i = 0; i  3
x.destroy (ложь); // => ложь
Икс; // => [1, 2, true, undefined]
x.destroy (истина); // => правда
x.destroy (не определено); // => не определено
Икс; // => [1, 2]
x.destroy (3); // => ноль
Икс; // => [1, 2]
|
Обновление ES10
В этом посте суммируются общие подходы к удалению элементов из массива в ECMAScript 2019 (ES10).
1. Общие случаи
1.1. Удаление элемента массива по значению с помощью .splice ()
| На месте: Да |
| Удаляет дубликаты: Да (цикл), Нет (indexOf) |
| По значению / индексу: По индексу |
Если вы знаете значение, которое хотите удалить из массива, вы можете использовать метод splice. Сначала вы должны определить индекс целевого элемента. Затем вы используете индекс в качестве начального элемента и удаляете только один элемент.
// С циклом for
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (let i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// С помощью метода .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Удаление элемента массива с помощью метода .filter ()
| На месте: Нет |
| Удаляет дубликаты: Да |
| По значению / индексу: По значению |
Определенный элемент можно отфильтровать из массива, предоставив функцию фильтрации. Затем такая функция вызывается для каждого элемента в массиве.
значение const = 3
пусть arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == значение)
console.log (прибл)
// [1, 2, 4, 5]
1.3. Удаление элемента Array путем расширения Array.prototype
| На месте: Да / Нет (зависит от реализации) |
| Удаляет дубликаты: Да / Нет (зависит от реализации) |
| По значению / индексу: По индексу / по значению (зависит от реализации) |
Прототип массива может быть расширен дополнительными методами. Затем такие методы будут доступны для использования в созданных массивах.
Примечание. Расширение прототипов объектов из стандартной библиотеки JavaScript (например, Array) рассматривается некоторыми как антипаттерн.
// На месте, удаляет все, по реализации значения
Array.prototype.remove = function (item) {
for (let i = 0; i  = ES10)
| На месте: Нет |
| Удаляет дубликаты: Да |
| По значению / индексу: По значению |
ES10 представил Object.fromEntries, который может бытьиспользуется для создания желаемого массива из любого объекта, подобного массиву, и фильтрации нежелательных элементов во время процесса.
константный объект = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (объект)
.filter (([ключ, val]) => val! == valueToRemove)
));
console.log (об); // [1,2,4]
2. Особые случаи
2.1 Удаление элемента, если он находится в конце массива
2.1.1. Изменение длины массива
| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N / A |
Элементы массива JavaScript можно удалить из конца массива, установив для свойства length значение меньше текущего. Любой элемент, индекс которого больше или равен новой длине, будет удален.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Устанавливаем длину для удаления элемента
console.log (об); // [1, 2, 3, 4, 5]
2.1.2. Использование метода .pop ()
| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N / A |
Метод pop удаляет последний элемент массива, возвращает этот элемент и обновляет свойство length. Метод pop изменяет массив, для которого он вызывается. Это означает, что в отличие от использования delete последний элемент полностью удаляется, а длина массива уменьшается.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // возвращает 6
console.log (об); // [1, 2, 3, 4, 5]
2.2. Удаление элемента, если он находится в начале массива
| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N / A |
Метод .shift () работает так же, как метод pop, за исключением того, что он удаляет первый элемент массива JavaScript вместо последнего. Когда элемент удаляется, остальные элементы смещаются вниз.
const arr = [1, 2, 3, 4];
arr.shift (); // возвращает 1
console.log (об); // [2, 3, 4]
2.3. Удаление элемента, если это единственный элемент в массиве
| На месте: Да |
| Удаляет дубликаты: N / A |
| По стоимости / индексу: N / A |
Самый быстрый способ - присвоить переменной массива пустой массив.
пусть arr = [1];
arr = []; // пустой массив
В качестве альтернативы можно использовать технику из 2.1.1, установив длину на 0.
|
Вы никогда не должны изменять свой массив. Поскольку это противоречит шаблону функционального программирования. Вы можете создать новый массив, не ссылаясь на массив, данные которого вы хотите изменить, используя фильтр метода ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Предположим, вы хотите удалить 5 из массива, вы можете просто сделать это так:
myArray = myArray.filter (значение => значение! == 5);
Это даст вам новый массив без значения, которое вы хотели удалить. Итак, результат будет:
[1, 2, 3, 4, 6]; // 5 было удалено из этого массива
Для дальнейшего понимания вы можете прочитать документацию MDN на Array.filter.
|
Более современный подход, ECMAScript 2015 (ранее известный как Harmony или ES 6). Дано:
const items = [1, 2, 3, 4];
const index = 2;
Затем:
items.filter ((x, i) => i! == index);
Урожайность:
[1, 2, 4]
Вы можете использовать Babel и службу polyfill, чтобы убедиться, что это хорошо поддерживается в браузерах.
|
Вы можете выполнить обратный цикл, чтобы не испортить индексы, если существует несколько экземпляров элемента.
var myElement = "шоколад";
var myArray = ['шоколад', 'poptart', 'poptart', 'poptart', 'шоколад', 'poptart', 'poptart', 'шоколад'];
/ * Важный код * /
for (var i = myArray.length - 1; i> = 0; i--) {
если (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Живая демонстрация
|
У вас есть от 1 до 9 в массиве, и вы хотите удалить 5. Используйте следующий код:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
вернуть m! == 5;
});
console.log («новый массив, 5 удалено», newNumberArray);
Если вы хотите несколько значений. Пример: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log («новый массив, 1,7 и 8 удалены», newNumberArray);
Если вы хотите удалить значение массива в массиве. Пример: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (м);
});
console.log («новый массив, [3,4,5] удален», newNumberArray);
Включает поддерживаемый браузер по ссылке.
|
1
2
3
4
следующий
Весьма активный вопрос. Заработайте 10 репутации, чтобы ответить на этот вопрос. Требование репутации помогает защитить этот вопрос от спама и отсутствия ответов.
Не тот ответ, который вы ищете? Просмотрите другие вопросы с метками массивы javascript или задайте свой вопрос.